

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Web.Services;
    using HER;
    using AEL.ACT;
    using BEL;
    using CEL.ACT;
  namespace EWS
  {
  /// <summary>
  /// Summary description for WS_ACT
  /// </summary>
  [WebService(Namespace = "http://koala.org/")]
  [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
  [ToolboxItem(false)]
  public class WS_ACT : WebService
  {
   // Posible problema con static y nuevas consultas a la base
   // se debería optimizar la llamada a los objeto DO, 
  // para que esté creado desde el momento de la llamada
   // o
  // que problema existe en concurrencia??
    #region Servicios para Act_Atributo
    // Objeto permanente para acceso a DO_Act_Atributo
    private DO_Act_Atributo _Act_Atributo ;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Atributo
    /// </summary>
    public DO_Act_Atributo Act_Atributo
    {
    get
    {
    if(_Act_Atributo == null)
    _Act_Atributo = new DO_Act_Atributo ();
    return _Act_Atributo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Atributo> Act_Atributo_Get(Scope s)
    {
     return Act_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Atributo
    /// </summary>
    /// <returns>Todos los registros de Act_Atributo </returns>
    
        [WebMethod]
        public List< Act_Atributo> Act_Atributo_GetByCodigo ( Scope s, string Codigo)
        {
        return Act_Atributo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Act_Atributo> Act_Atributo_GetByEmpresa ( Scope s)
        {
        return Act_Atributo.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Act_Atributo> Act_Atributo_GetById ( Scope s, string Id)
        {
        return Act_Atributo.GetById(s, Id );
        }
        [WebMethod]
        public List<Act_Atributo> Act_Atributo_GetByLikeNombre(Scope s, string Nombre)
        {
        return Act_Atributo.GetByLikeNombre(s, Nombre);
        }
    #endregion
    #region  Operaciones con datos de la tabla Act_Atributo
    /// <summary>
    /// Borra el objeto de Act_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Atributo_Delete(Scope s, Act_Atributo o)
    {
    try
    {
    return Act_Atributo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Act_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Atributo_Insert(Scope s, Act_Atributo o)
    {
    try
    {
    return Act_Atributo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Atributo_Update (Scope s, Act_Atributo o, Act_Atributo original)
    {
    try
    {
    return Act_Atributo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Act_Grupo
    // Objeto permanente para acceso a DO_Act_Grupo
    private DO_Act_Grupo _Act_Grupo ;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Grupo
    /// </summary>
    public DO_Act_Grupo Act_Grupo
    {
    get
    {
    if(_Act_Grupo == null)
    _Act_Grupo = new DO_Act_Grupo ();
    return _Act_Grupo ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Grupo> Act_Grupo_Get(Scope s)
    {
     return Act_Grupo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Grupo
    /// </summary>
    /// <returns>Todos los registros de Act_Grupo </returns>
    
        [WebMethod]
        public List< Act_Grupo> Act_Grupo_GetByCodigo ( Scope s, string Codigo)
        {
        return Act_Grupo.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Act_Grupo> Act_Grupo_GetByEmpresa ( Scope s)
        {
        return Act_Grupo.GetByEmpresa(s);
        }
        [WebMethod]
        public List< Act_Grupo> Act_Grupo_GetById ( Scope s, string Id)
        {
        return Act_Grupo.GetById(s, Id );
        }
        [WebMethod]
        public List<Act_Grupo> Act_Grupo_GetByLikeNombre(Scope s, string Nombre)
        {
        return Act_Grupo.GetByLikeNombre(s, Nombre);
        } 
    #endregion
    #region  Operaciones con datos de la tabla Act_Grupo
    /// <summary>
    /// Borra el objeto de Act_Grupo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Grupo_Delete(Scope s, Act_Grupo o)
    {
    try
    {
    return Act_Grupo.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Act_Grupo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Grupo_Insert(Scope s, Act_Grupo o)
    {
    try
    {
    return Act_Grupo.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Grupo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Grupo_Update (Scope s, Act_Grupo o, Act_Grupo original)
    {
    try
    {
    return Act_Grupo.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion
    
    #region Servicios para Act_Grupo_Det
    // Objeto permanente para acceso a DO_Act_Grupo_Det
    private DO_Act_Grupo_Det _Act_Grupo_Det ;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Grupo_Det
    /// </summary>
    public DO_Act_Grupo_Det Act_Grupo_Det
    {
    get
    {
    if(_Act_Grupo_Det == null)
    _Act_Grupo_Det = new DO_Act_Grupo_Det ();
    return _Act_Grupo_Det ;
    }
    }
    
    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Grupo_Det> Act_Grupo_Det_Get(Scope s)
    {
     return Act_Grupo_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Grupo_Det
    /// </summary>
    /// <returns>Todos los registros de Act_Grupo_Det </returns>
    
        [WebMethod]
        public List< Act_Grupo_Det> Act_Grupo_Det_GetByCodigo ( Scope s, string Codigo)
        {
        return Act_Grupo_Det.GetByCodigo(s, Codigo );
        }
        [WebMethod]
        public List< Act_Grupo_Det> Act_Grupo_Det_GetByGrupo ( Scope s, string Act_Grupo_Id)
        {
        return Act_Grupo_Det.GetByGrupo(s, Act_Grupo_Id );
        }
        [WebMethod]
        public List< Act_Grupo_Det> Act_Grupo_Det_GetById ( Scope s, string Id)
        {
        return Act_Grupo_Det.GetById(s, Id );
        }
      [WebMethod]
      public List<Act_Grupo_Det> Act_Grupo_Det_GetByLikeNombre(Scope s, string Nombre, string Act_Grupo_Id)
      {
          return Act_Grupo_Det.GetByLikeNombre(s, Nombre,Act_Grupo_Id);
      }
    #endregion
    #region  Operaciones con datos de la tabla Act_Grupo_Det
    /// <summary>
    /// Borra el objeto de Act_Grupo_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Grupo_Det_Delete(Scope s, Act_Grupo_Det o)
    {
    try
    {
    return Act_Grupo_Det.Delete(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Inserta el objeto en Act_Grupo_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Grupo_Det_Insert(Scope s, Act_Grupo_Det o)
    {
    try
    {
    return Act_Grupo_Det.Insert(s,o);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Grupo_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Grupo_Det_Update (Scope s, Act_Grupo_Det o, Act_Grupo_Det original)
    {
    try
    {
    return Act_Grupo_Det.Update(s,o,original);
    }
    catch (Exception e)
    {
    throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
    }
    }
    #endregion
    #endregion

    #region Servicios para Act_Clase
    // Objeto permanente para acceso a DO_Act_Clase
    private DO_Act_Clase _Act_Clase;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Clase
    /// </summary>
    public DO_Act_Clase Act_Clase
    {
        get
        {
            if (_Act_Clase == null)
                _Act_Clase = new DO_Act_Clase();
            return _Act_Clase;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Clase> Act_Clase_Get(Scope s)
    {
        return Act_Clase.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Clase
    /// </summary>
    /// <returns>Todos los registros de Act_Clase </returns>

    [WebMethod]
    public List<Act_Clase> Act_Clase_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Clase.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Clase> Act_Clase_GetByEmpresa(Scope s)
    {
        return Act_Clase.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Act_Clase> Act_Clase_GetById(Scope s, string Id)
    {
        return Act_Clase.GetById(s, Id);
    }
      [WebMethod]
      public List<Act_Clase> Act_Clase_GetByLikeNombre(Scope s, string Nombre)
      {
          return Act_Clase.GetByLikeNombre(s, Nombre);
      }
    #endregion
    #region  Operaciones con datos de la tabla Act_Clase
    /// <summary>
    /// Borra el objeto de Act_Clase
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Clase_Delete(Scope s, Act_Clase o)
    {
        try
        {
            return Act_Clase.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Clase
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Clase_Insert(Scope s, Act_Clase o)
    {
        try
        {
            return Act_Clase.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Clase
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Clase_Update(Scope s, Act_Clase o, Act_Clase original)
    {
        try
        {
            return Act_Clase.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Clase_Atributo
    // Objeto permanente para acceso a DO_Act_Clase_Atributo
    private DO_Act_Clase_Atributo _Act_Clase_Atributo;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Clase_Atributo
    /// </summary>
    public DO_Act_Clase_Atributo Act_Clase_Atributo
    {
        get
        {
            if (_Act_Clase_Atributo == null)
                _Act_Clase_Atributo = new DO_Act_Clase_Atributo();
            return _Act_Clase_Atributo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Clase_Atributo> Act_Clase_Atributo_Get(Scope s)
    {
        return Act_Clase_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Clase_Atributo
    /// </summary>
    /// <returns>Todos los registros de Act_Clase_Atributo </returns>

    [WebMethod]
    public List<Act_Clase_Atributo> Act_Clase_Atributo_GetByClase(Scope s, string Act_Clase_Id)
    {
        return Act_Clase_Atributo.GetByClase(s, Act_Clase_Id);
    }
    [WebMethod]
    public List<Act_Clase_Atributo> Act_Clase_Atributo_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Clase_Atributo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Clase_Atributo> Act_Clase_Atributo_GetById(Scope s, string Id)
    {
        return Act_Clase_Atributo.GetById(s, Id);
    }
   
    #endregion
    #region  Operaciones con datos de la tabla Act_Clase_Atributo
    /// <summary>
    /// Borra el objeto de Act_Clase_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Clase_Atributo_Delete(Scope s, Act_Clase_Atributo o)
    {
        try
        {
            return Act_Clase_Atributo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Clase_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Clase_Atributo_Insert(Scope s, Act_Clase_Atributo o)
    {
        try
        {
            return Act_Clase_Atributo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Clase_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Clase_Atributo_Update(Scope s, Act_Clase_Atributo o, Act_Clase_Atributo original)
    {
        try
        {
            return Act_Clase_Atributo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Ubicacion
    // Objeto permanente para acceso a DO_Act_Ubicacion
    private DO_Act_Ubicacion _Act_Ubicacion;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Ubicacion
    /// </summary>
    public DO_Act_Ubicacion Act_Ubicacion
    {
        get
        {
            if (_Act_Ubicacion == null)
                _Act_Ubicacion = new DO_Act_Ubicacion();
            return _Act_Ubicacion;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Ubicacion> Act_Ubicacion_Get(Scope s)
    {
        return Act_Ubicacion.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Ubicacion
    /// </summary>
    /// <returns>Todos los registros de Act_Ubicacion </returns>

    [WebMethod]
    public List<Act_Ubicacion> Act_Ubicacion_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Ubicacion.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Ubicacion> Act_Ubicacion_GetByEmpresa(Scope s)
    {
        return Act_Ubicacion.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Act_Ubicacion> Act_Ubicacion_GetById(Scope s, string Id)
    {
        return Act_Ubicacion.GetById(s, Id);
    }
    [WebMethod]
    public List<Act_Ubicacion> Act_Ubicacion_GetByLikeNombre(Scope s, string Nombre)
    {
      return Act_Ubicacion.GetByLikeNombre(s, Nombre);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Ubicacion
    /// <summary>
    /// Borra el objeto de Act_Ubicacion
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Ubicacion_Delete(Scope s, Act_Ubicacion o)
    {
        try
        {
            return Act_Ubicacion.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Ubicacion
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Ubicacion_Insert(Scope s, Act_Ubicacion o)
    {
        try
        {
            return Act_Ubicacion.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Ubicacion
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Ubicacion_Update(Scope s, Act_Ubicacion o, Act_Ubicacion original)
    {
        try
        {
            return Act_Ubicacion.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Ubicacion_Personal
    // Objeto permanente para acceso a DO_Act_Ubicacion_Personal
    private DO_Act_Ubicacion_Personal _Act_Ubicacion_Personal;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Ubicacion_Personal
    /// </summary>
    public DO_Act_Ubicacion_Personal Act_Ubicacion_Personal
    {
        get
        {
            if (_Act_Ubicacion_Personal == null)
                _Act_Ubicacion_Personal = new DO_Act_Ubicacion_Personal();
            return _Act_Ubicacion_Personal;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Ubicacion_Personal> Act_Ubicacion_Personal_Get(Scope s)
    {
        return Act_Ubicacion_Personal.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Ubicacion_Personal
    /// </summary>
    /// <returns>Todos los registros de Act_Ubicacion_Personal </returns>

    [WebMethod]
    public List<Act_Ubicacion_Personal> Act_Ubicacion_Personal_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Ubicacion_Personal.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Ubicacion_Personal> Act_Ubicacion_Personal_GetById(Scope s, string Id)
    {
        return Act_Ubicacion_Personal.GetById(s, Id);
    }
  
    [WebMethod]
    public List<Act_Ubicacion_Personal> Act_Ubicacion_Personal_GetByUbicacion(Scope s, string Act_Ubicacion_Id)
    {
        return Act_Ubicacion_Personal.GetByUbicacion(s, Act_Ubicacion_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Ubicacion_Personal
    /// <summary>
    /// Borra el objeto de Act_Ubicacion_Personal
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Ubicacion_Personal_Delete(Scope s, Act_Ubicacion_Personal o)
    {
        try
        {
            return Act_Ubicacion_Personal.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Ubicacion_Personal
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Ubicacion_Personal_Insert(Scope s, Act_Ubicacion_Personal o)
    {
        try
        {
            return Act_Ubicacion_Personal.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Ubicacion_Personal
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Ubicacion_Personal_Update(Scope s, Act_Ubicacion_Personal o, Act_Ubicacion_Personal original)
    {
        try
        {
            return Act_Ubicacion_Personal.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Activo_Atributo
    // Objeto permanente para acceso a DO_Act_Activo_Atributo
    private DO_Act_Activo_Atributo _Act_Activo_Atributo;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Activo_Atributo
    /// </summary>
    public DO_Act_Activo_Atributo Act_Activo_Atributo
    {
        get
        {
            if (_Act_Activo_Atributo == null)
                _Act_Activo_Atributo = new DO_Act_Activo_Atributo();
            return _Act_Activo_Atributo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Activo_Atributo> Act_Activo_Atributo_Get(Scope s)
    {
        return Act_Activo_Atributo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Activo_Atributo
    /// </summary>
    /// <returns>Todos los registros de Act_Activo_Atributo </returns>

    [WebMethod]
    public List<Act_Activo_Atributo> Act_Activo_Atributo_GetByActivo(Scope s, string Act_Activo_Id)
    {
        return Act_Activo_Atributo.GetByActivo(s, Act_Activo_Id);
    }
    [WebMethod]
    public List<Act_Activo_Atributo> Act_Activo_Atributo_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Activo_Atributo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Activo_Atributo> Act_Activo_Atributo_GetById(Scope s, string Id)
    {
        return Act_Activo_Atributo.GetById(s, Id);
    }
      
    #endregion
    #region  Operaciones con datos de la tabla Act_Activo_Atributo
    /// <summary>
    /// Borra el objeto de Act_Activo_Atributo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Activo_Atributo_Delete(Scope s, Act_Activo_Atributo o)
    {
        try
        {
            return DEL.ACT.DO_Act_Activo_Atributo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Activo_Atributo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Activo_Atributo_Insert(Scope s, Act_Activo_Atributo o)
    {
        try
        {
            return Act_Activo_Atributo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Activo_Atributo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Activo_Atributo_Update(Scope s, Act_Activo_Atributo o, Act_Activo_Atributo original)
    {
        try
        {
            return Act_Activo_Atributo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Activo_Manual
    // Objeto permanente para acceso a DO_Act_Activo_Manual
    private DO_Act_Activo_Manual _Act_Activo_Manual;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Activo_Manual
    /// </summary>
    public DO_Act_Activo_Manual Act_Activo_Manual
    {
        get
        {
            if (_Act_Activo_Manual == null)
                _Act_Activo_Manual = new DO_Act_Activo_Manual();
            return _Act_Activo_Manual;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Activo_Manual> Act_Activo_Manual_Get(Scope s)
    {
        return Act_Activo_Manual.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Activo_Manual
    /// </summary>
    /// <returns>Todos los registros de Act_Activo_Manual </returns>

    [WebMethod]
    public List<Act_Activo_Manual> Act_Activo_Manual_GetByActivo(Scope s, string Act_Activo_Id)
    {
        return Act_Activo_Manual.GetByActivo(s, Act_Activo_Id);
    }
    [WebMethod]
    public List<Act_Activo_Manual> Act_Activo_Manual_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Activo_Manual.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Activo_Manual> Act_Activo_Manual_GetById(Scope s, string Id)
    {
        return Act_Activo_Manual.GetById(s, Id);
    }
      
    #endregion
    #region  Operaciones con datos de la tabla Act_Activo_Manual
    /// <summary>
    /// Borra el objeto de Act_Activo_Manual
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Activo_Manual_Delete(Scope s, Act_Activo_Manual o)
    {
        try
        {
            return Act_Activo_Manual.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Activo_Manual
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Activo_Manual_Insert(Scope s, Act_Activo_Manual o)
    {
        try
        {
            return Act_Activo_Manual.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Activo_Manual
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Activo_Manual_Update(Scope s, Act_Activo_Manual o, Act_Activo_Manual original)
    {
        try
        {
            return Act_Activo_Manual.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion 

    #region Servicios para Act_Activo
    // Objeto permanente para acceso a DO_Act_Activo
    private DO_Act_Activo _Act_Activo;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Activo
    /// </summary>
    public DO_Act_Activo Act_Activo
    {
        get
        {
            if (_Act_Activo == null)
                _Act_Activo = new DO_Act_Activo();
            return _Act_Activo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Activo> Act_Activo_Get(Scope s)
    {
        return Act_Activo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Activo
    /// </summary>
    /// <returns>Todos los registros de Act_Activo </returns>

    [WebMethod]
    public List<Act_Activo> Act_Activo_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Activo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Activo> Act_Activo_GetByEmpresa(Scope s)
    {
        return Act_Activo.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Act_Activo> Act_Activo_GetById(Scope s, string Id)
    {
        return Act_Activo.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Activo
    /// <summary>
    /// Borra el objeto de Act_Activo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Activo_Delete(Scope s, Act_Activo o)
    {
        try
        {
            int resultado = DEL.ACT.DO_Act_Activo.Delete(s, o);
            return resultado;
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Activo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Activo_Insert(Scope s, Act_Activo o)
    {
        try
        {
            string resultado = DEL.ACT.DO_Act_Activo.Insert(s, o);
            return resultado;
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Activo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Activo_Update(Scope s, Act_Activo o, Act_Activo original)
    {
        try
        {
            return Act_Activo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Activo_Archivo
    // Objeto permanente para acceso a DO_Act_Activo_Archivo
    private DO_Act_Activo_Archivo _Act_Activo_Archivo;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Activo_Archivo
    /// </summary>
    public DO_Act_Activo_Archivo Act_Activo_Archivo
    {
        get
        {
            if (_Act_Activo_Archivo == null)
                _Act_Activo_Archivo = new DO_Act_Activo_Archivo();
            return _Act_Activo_Archivo;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Activo_Archivo> Act_Activo_Archivo_Get(Scope s)
    {
        return Act_Activo_Archivo.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Activo_Archivo
    /// </summary>
    /// <returns>Todos los registros de Act_Activo_Archivo </returns>

    [WebMethod]
    public List<Act_Activo_Archivo> Act_Activo_Archivo_GetByActivo(Scope s, string Act_Activo_Id)
    {
        return Act_Activo_Archivo.GetByActivo(s, Act_Activo_Id);
    }
    [WebMethod]
    public List<Act_Activo_Archivo> Act_Activo_Archivo_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Activo_Archivo.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Activo_Archivo> Act_Activo_Archivo_GetById(Scope s, string Id)
    {
        return Act_Activo_Archivo.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Activo_Archivo
    /// <summary>
    /// Borra el objeto de Act_Activo_Archivo
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Activo_Archivo_Delete(Scope s, Act_Activo_Archivo o)
    {
        try
        {
            return Act_Activo_Archivo.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Activo_Archivo
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Activo_Archivo_Insert(Scope s, Act_Activo_Archivo o)
    {
        try
        {
            return Act_Activo_Archivo.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Activo_Archivo
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Activo_Archivo_Update(Scope s, Act_Activo_Archivo o, Act_Activo_Archivo original)
    {
        try
        {
            return Act_Activo_Archivo.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion

    #region Servicios para Act_Activo_Imagen
    // Objeto permanente para acceso a DO_Act_Activo_Imagen
    private DO_Act_Activo_Imagen _Act_Activo_Imagen;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Activo_Imagen
    /// </summary>
    public DO_Act_Activo_Imagen Act_Activo_Imagen
    {
        get
        {
            if (_Act_Activo_Imagen == null)
                _Act_Activo_Imagen = new DO_Act_Activo_Imagen();
            return _Act_Activo_Imagen;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Activo_Imagen> Act_Activo_Imagen_Get(Scope s)
    {
        return Act_Activo_Imagen.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Activo_Imagen
    /// </summary>
    /// <returns>Todos los registros de Act_Activo_Imagen </returns>

    [WebMethod]
    public List<Act_Activo_Imagen> Act_Activo_Imagen_GetByActivo(Scope s, string Act_Activo_Id)
    {
        return Act_Activo_Imagen.GetByActivo(s, Act_Activo_Id);
    }
    [WebMethod]
    public List<Act_Activo_Imagen> Act_Activo_Imagen_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Activo_Imagen.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Activo_Imagen> Act_Activo_Imagen_GetById(Scope s, string Id)
    {
        return Act_Activo_Imagen.GetById(s, Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Activo_Imagen
    /// <summary>
    /// Borra el objeto de Act_Activo_Imagen
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Activo_Imagen_Delete(Scope s, Act_Activo_Imagen o)
    {
        try
        {
            return Act_Activo_Imagen.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Activo_Imagen
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Activo_Imagen_Insert(Scope s, Act_Activo_Imagen o)
    {
        try
        {
            return Act_Activo_Imagen.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Activo_Imagen
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Activo_Imagen_Update(Scope s, Act_Activo_Imagen o, Act_Activo_Imagen original)
    {
        try
        {
            return Act_Activo_Imagen.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
      #endregion

    #region Servicios para Act_Atributo_Det
    // Objeto permanente para acceso a DO_Act_Atributo_Det
    private DO_Act_Atributo_Det _Act_Atributo_Det;
    /// <summary>
    /// La propiedad para acceso a DO_Act_Atributo_Det
    /// </summary>
    public DO_Act_Atributo_Det Act_Atributo_Det
    {
        get
        {
            if (_Act_Atributo_Det == null)
                _Act_Atributo_Det = new DO_Act_Atributo_Det();
            return _Act_Atributo_Det;
        }
    }

    #region Obtención  de Datos
    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_Get(Scope s)
    {
        return Act_Atributo_Det.Get(s);
    }
    /// <summary>
    /// Retorna todos los datos de Act_Atributo_Det
    /// </summary>
    /// <returns>Todos los registros de Act_Atributo_Det </returns>

    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_GetByAtributo(Scope s, string Act_Atributo_Id)
    {
        return Act_Atributo_Det.GetByAtributo(s, Act_Atributo_Id);
    }
    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_GetByCodigo(Scope s, string Codigo)
    {
        return Act_Atributo_Det.GetByCodigo(s, Codigo);
    }
    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_GetByEmpresa(Scope s)
    {
        return Act_Atributo_Det.GetByEmpresa(s);
    }
    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_GetById(Scope s, string Id)
    {
        return Act_Atributo_Det.GetById(s, Id);
    }
    [WebMethod]
    public List<Act_Atributo_Det> Act_Atributo_Det_GetByLikeNombre(Scope s,string Nombre, string Act_Atributo_Id)
    {
        return Act_Atributo_Det.GetByLikeNombre(s,Nombre, Act_Atributo_Id);
    }
    #endregion
    #region  Operaciones con datos de la tabla Act_Atributo_Det
    /// <summary>
    /// Borra el objeto de Act_Atributo_Det
    /// </summary>
    /// <param name="o">El objeto a borrar</param>
    /// <returns></returns>
    [WebMethod]
    public int Act_Atributo_Det_Delete(Scope s, Act_Atributo_Det o)
    {
        try
        {
            return Act_Atributo_Det.Delete(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Inserta el objeto en Act_Atributo_Det
    /// </summary>
    /// <param name="s"></param>
    /// <param name="o">El objeto a insertar</param>
    /// <returns></returns>
    [WebMethod]
    public string Act_Atributo_Det_Insert(Scope s, Act_Atributo_Det o)
    {
        try
        {
            return Act_Atributo_Det.Insert(s, o);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    /// <summary>
    /// Actualiza el módulo en Act_Atributo_Det
    /// </summary>
    /// <param name="o">El objeto a actualizar</param>
    /// <returns></returns>
    /// <param name="original"></param>
    [WebMethod]
    public int Act_Atributo_Det_Update(Scope s, Act_Atributo_Det o, Act_Atributo_Det original)
    {
        try
        {
            return Act_Atributo_Det.Update(s, o, original);
        }
        catch (Exception e)
        {
            throw Error.ConstruirExcepcion(e, Context.Request.Url.AbsoluteUri);
        }
    }
    #endregion
    #endregion
    
    }
  }
  
